package com.chen.function_demo.chapter3;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 第三章第二节
 * @author 陈哲<p>
 * ================================<p>
 * Date: 2025/5/11<p>
 * Time: 23:32<p>
 * ================================
 */
public class Section2 {
    /*
        1、构建流：
        （1）集合构建：集合.stream();
        （2）数组构建：Arrays.stream(数组);
        （3）从对象构建：Stream.of(T... values);
        2、流的合并与截取
        （1）流合并：Stream.concat(Stream a, Stream b)：合并两个流，返回一个新的流；
        （2）流截取：
            1️⃣根据位置：Stream.skip(?).limit(?)
            2️⃣根据条件：Stream.takeWhile(条件)；
            3️⃣根据条件：Stream.dropWhile(条件)
     */
    public static void main(String[] args) {
        // 1、集合构建流 Collection及子接口都是集合.stream()
        List<Integer> list = List.of(1, 2, 3, 4, 5);
        Stream<Integer> stream = list.stream();
        // Map怎么创建流
        Map<String, Integer> map = Map.of("a", 1, "b", 2, "c", 3);
        Set<String> strings = map.keySet();
        // map的keySet是Set本质上就是Collection，所以用集合.stream()创建流
        Stream<String> stringStream = strings.stream();
        // 2、数组构建流 Arrays.stream(数组);
        int[] intArray = {1, 2, 3, 4, 5};
        IntStream stream1 = Arrays.stream(intArray);
        String[] strings1 = {"a", "b", "c"};
        Stream<String> stream2 = Arrays.stream(strings1);
        // 3、从对象构建流 Stream.of(T... values); 对象是一个或多个
        Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5);
        Stream<Student> studentStream = Stream.of(new Student("张三", 100, 18), new Student("李四", 90, 19));
        Stream<String> stream4 = Stream.of("1");
        System.out.println("========================================");
        /*
            截取 -根据位置截取
            1、limit(n)：返回一个不超过n（假如n大于元素总个数的话）的流，与skip互补。
            2、skip(n)：跳过前n个元素，返回一个扔掉前n个元素的流，如果流中元素不足n个，则返回一个空流，与limit(n)互补。
         */
        Stream.of(1, 2, 3, 4, 5).skip(3).forEach(System.out::println);
        System.out.println("-----------------------------------------");
        // 总共5个元素，跳过6个 可以发现打印的是个空流
        Stream.of(1, 2, 3, 4, 5).skip(6).forEach(System.out::println);
        System.out.println("-----------------------------------------");
        Stream.of(1, 2, 3, 4, 5).limit(3).forEach(System.out::println);
        System.out.println("-----------------------------------------");
        // 总共5个元素，限制前6个 可以发现也只有前5个
        Stream.of(1, 2, 3, 4, 5).limit(6).forEach(System.out::println);
        System.out.println("-----------------------------------------");
        // 取中间的两个就可以先跳过2个，再限制2个
        Stream.of(1, 2, 3, 4, 5).skip(2).limit(2).forEach(System.out::println);
        /*
            截取 -根据条件确定截取位置
            1、takeWhile(Predicate)：条件成立保留，直到条件不成立（一但条件不成立，剩下的不要）
            返回一个满足条件的流，如果流中元素不满足条件，则返回一个空流，与dropWhile互补。
            2、dropWhile(Predicate)：条件成立丢弃，直到条件不成立（一但条件不成立，剩下的保留）
         */
        System.out.println("=========================================");
        // 只会打印1，2 后面即使存在小于3的也会被舍弃
        Stream.of(1, 2, 3, 4, 5, 1, 2).takeWhile(x -> x < 3).forEach(System.out::println);
        // 只会舍弃最前面的1，2 后面即使存在小于3的也会被保留
        System.out.println("-----------------------------------------");
        Stream.of(1, 2, 3, 4, 5, 1, 2).dropWhile(x -> x < 3).forEach(System.out::println);
    }

    record Student(String name, int score, int age) {}
}
